/*
 * ManejadorConfiguracion.cpp
 *
 *  Created on: 10/09/2010
 *      Author: julfc, luciano.lattes
 */

#include "ManejadorConfiguracion.h"

const std::string ManejadorConfiguracion::EXTENSION_ARCHIVO = ".dat";
const std::string ManejadorConfiguracion::PROPIEDAD_VALOR = "VALOR_";

const std::string ManejadorConfiguracion::TAMANIO_PARAM = "tamanioBloque";
const std::string ManejadorConfiguracion::CANTIDAD_MAILS = "cantidadMails";
const std::string ManejadorConfiguracion::TAM_MATRIZ = "tamanioMatriz";
const std::string ManejadorConfiguracion::LIBSPOPC = "libspopc";

const long ManejadorConfiguracion::BYTES_IN_KB = 1024;

// Tipos de filtro.
const std::string ManejadorConfiguracion::TIPO_SELECCION = "SELECCION";
const std::string ManejadorConfiguracion::TIPO_CLASIFICACION = "CLASIFICACION";
const std::string ManejadorConfiguracion::TIPO_LISTA = "LISTA";

// Condicion para el filtro.
const std::string ManejadorConfiguracion::ORIGEN = "ORIGEN";
const std::string ManejadorConfiguracion::DESTINO = "DESTINO";
const std::string ManejadorConfiguracion::ASUNTO = "ASUNTO";
const std::string ManejadorConfiguracion::FECHA = "FECHA";
const std::string ManejadorConfiguracion::RESPUESTA_A = "RESPUESTA";

ManejadorConfiguracion::ManejadorConfiguracion() {
}

bool ManejadorConfiguracion::crearFiltro(const std::string& tipo,
    const std::string& condicion, const std::string& username) {

  return crearFiltro(tipo, condicion, "", username);
}

bool ManejadorConfiguracion::crearFiltro(const std::string& tipo,
    const std::string& condicion, const std::string& valorSeleccion,
    const std::string& username) {

  std::string clave = "";
  std::string valor = "";

  configuracion.irAlFinal();

  if (valorSeleccion.empty() &&
      tipo.compare(ManejadorConfiguracion::TIPO_CLASIFICACION) == 0) {
    clave = tipo + "." + condicion + "." + username;
    valor = tipo + condicion + username + EXTENSION_ARCHIVO;
    configuracion.crearPropiedad(clave, valor);
    clave += ".LISTA";
    valor = tipo + condicion + username + "LISTA" + EXTENSION_ARCHIVO;
    configuracion.crearPropiedad(clave, valor);
    return true;
  } else if (!valorSeleccion.empty() &&
      tipo.compare(ManejadorConfiguracion::TIPO_SELECCION) == 0) {
    // Crea la propiedad correspondiente al tipo de filtro.
    clave = tipo + "." + condicion + "." + valorSeleccion + "." + username;
    valor = tipo + condicion + valorSeleccion + username + EXTENSION_ARCHIVO;
    configuracion.crearPropiedad(clave, valor);
    return true;
  } else {
    return false;
  }
}

long ManejadorConfiguracion::obtenerTamanioBloque() {
  std::string stringValor = configuracion.retornarValor(TAMANIO_PARAM);
  if (stringValor.size() > 0) {
    return atol(stringValor.c_str());
  } else {
    return 32; // Defecto a 32 Kb.
  }
}

bool ManejadorConfiguracion::eliminarFiltro(const std::string& tipo,
		const std::string& condicion, const std::string& valorSeleccion,
		const std::string& username) {

	std::string clave = "";
	std::string valor = "";

	configuracion.irAlPrincipio();

	if (valorSeleccion.empty() && tipo.compare(
			ManejadorConfiguracion::TIPO_CLASIFICACION) == 0) {
		clave = tipo + "." + condicion + "." + username;
		configuracion.eliminarEntrada(clave);
		return true;
	} else if (tipo.compare(ManejadorConfiguracion::TIPO_SELECCION) == 0) {
		clave = tipo + "." + condicion + "." + valorSeleccion + "." + username;
		configuracion.eliminarEntrada(clave);
		return true;
	} else {
		return false;
	}
}

void ManejadorConfiguracion::limpiarConfiguracion() {
	configuracion.limpiarConf(ManejadorConfiguracion::TAMANIO_PARAM);
}

std::vector<std::string> ManejadorConfiguracion::obtenerParamsLibspopc() {
  std::vector<std::string> claves = configuracion.retornarGrupoClaves(LIBSPOPC);
  std::vector<std::string> valores;

  for (unsigned int i = 0; i < claves.size(); i++) {
    valores.push_back(configuracion.retornarValor(claves[i]));
  }

  return valores;
}

std::vector<std::string> ManejadorConfiguracion::obtenerIndices() {
  std::vector<std::string> clavesClasificacion = configuracion.retornarGrupoClaves(TIPO_LISTA);
  std::vector<std::string> clavesSeleccion = configuracion.retornarGrupoClaves(TIPO_SELECCION);
  std::vector<std::string> valores;

  for (unsigned int i = 0; i < clavesClasificacion.size(); i++) {
    valores.push_back(configuracion.retornarValor(clavesClasificacion[i]));
  }

  for (unsigned int j = 0; j < clavesSeleccion.size(); j++) {
    valores.push_back(configuracion.retornarValor(clavesSeleccion[j]));
  }

  return valores;
}

void ManejadorConfiguracion::guardarCantidadMails(long cantidad) {
  configuracion.eliminarEntrada(CANTIDAD_MAILS);
  std::ostringstream stream;
  stream << cantidad;
  configuracion.irAlFinal();
  configuracion.crearPropiedad(CANTIDAD_MAILS, stream.str());
}

long ManejadorConfiguracion::obtenerCantidadMails() {
  std::string cantidad = configuracion.retornarValor(CANTIDAD_MAILS);
  return atol(cantidad.c_str());
}

void ManejadorConfiguracion::guardarTamanioMatriz(long tamMatriz) {
	configuracion.eliminarEntrada(TAM_MATRIZ);
	std::ostringstream stream;
	stream << tamMatriz;
	configuracion.irAlFinal();
	configuracion.crearPropiedad(TAM_MATRIZ, stream.str());
}

long ManejadorConfiguracion::obtenerTamanioMatriz() {
  std::string matriz = configuracion.retornarValor(TAM_MATRIZ);
  return atol(matriz.c_str());
}

void ManejadorConfiguracion::modificarCantidadMails(long nuevaCantidad) {
  this->guardarCantidadMails(nuevaCantidad);
}

std::string ManejadorConfiguracion::obtenerValor(const std::string& clave) {
	return configuracion.retornarValor(clave);
}

